#include "DeviceManagementPlugin.h"
#include <QMetaObject>
#include <QDebug>
#include <QCoreApplication>
#include <QDialog>

/**
 * @brief DeviceManagementPlugin构造函数
 * @param parent 父对象指针，用于内存管理
 */
DeviceManagementPlugin::DeviceManagementPlugin(QObject *parent)
    : CameraPluginInterface(parent), m_SDKManager(nullptr) {
    // 初始化成员变量
}

/**
 * @brief DeviceManagementPlugin析构函数
 * @details 释放所有资源，包括设备管理界面和设备管理器
 */
DeviceManagementPlugin::~DeviceManagementPlugin() {
    // 释放设备管理界面资源
    delete m_pDeviceManagementWidget;
    // 释放设备管理器资源
    delete m_SDKManager;
}

/**
 * @brief 初始化插件
 * @details 创建设备管理器，加载SDK插件，建立信号槽连接，创建设备管理界面
 */
void DeviceManagementPlugin::initialize()
{
    // 创建设备管理器实例
    m_SDKManager = new SDKManager(this);
    // 加载SDK插件
    m_SDKManager->loadSDKs(QCoreApplication::applicationDirPath() + "/SDK");
    
    // 建立信号槽连接
    connect(m_SDKManager, &SDKManager::cameraConnected, this, &DeviceManagementPlugin::onCameraConnected);
    connect(m_SDKManager, &SDKManager::cameraDisconnected, this, &DeviceManagementPlugin::onCameraDisconnected);
    connect(m_SDKManager, &SDKManager::writeLog, this, &DeviceManagementPlugin::onWriteLog);
    
    // 创建设备管理界面并传递设备管理器指针
    m_pDeviceManagementWidget = new DeviceManagementWidget(m_SDKManager);
    // 注册设备管理界面到主框架
    emit registerWidgetToDock(DockWidgetType::DeviceControl, m_pDeviceManagementWidget);
}

/**
 * @brief 获取插件名称
 * @return 插件名称字符串
 */
QString DeviceManagementPlugin::pluginName() const {
    return DEVICE_MANAGEMENT_PLUGIN_NAME;
}

/**
 * @brief 获取插件描述
 * @return 插件描述字符串
 */
QString DeviceManagementPlugin::description() const {
    return "提供设备管理功能，包括相机管理和控制模块管理";
}

/**
 * @brief 设置图像采集回调
 * @param deviceId 设备ID
 * @param pObject 对象指针
 * @param callback 回调函数指针
 * @return 操作结果
 */
QVariant DeviceManagementPlugin::setImageCaptureCallback(const QVariant &deviceId, QVariant pObject, QVariant callback)
{
    // 将回调函数转换为函数指针
    void (*updateCameraImage)(QObject* ,const QString&, const QImage& , int)=
            reinterpret_cast<void (*)(QObject* ,const QString&, const QImage& , int)>(callback.value<qintptr>());
    
    // 获取对象指针
    QObject* ss = pObject.value<QObject*>();
    
    // 创建lambda表达式作为回调
    ImageCallback cback = [ss, updateCameraImage](const QString& guid, const QImage& image, int tm)
    {
        // 调用回调函数
        updateCameraImage(ss, guid, image, tm);
    };
    
    // 调用设备管理器的setImageCaptureCallback方法
    return m_SDKManager->setImageCaptureCallback(deviceId, cback);
}

/**
 * @brief 处理插件消息
 * @param sender 发送者名称
 * @param message 消息内容
 */
void DeviceManagementPlugin::onPluginMessage(const QString &sender, const QString &message)
{
    Q_UNUSED(sender);
    
    // 等主框架发出 FRAMEWORK_INITIALIZED 后再进行设备检索
    if (message == CMD_FRAMEWORK_INITIALIZED)
    {
        // 刷新设备列表
        m_pDeviceManagementWidget->on_refreshDevicesButton_clicked();
        
        // 处理控制模块SDK
        QList<ControlModuleSDKInterface*> controlModuleSDKs = m_SDKManager->loadedControlModuleSDKs();
        foreach(ControlModuleSDKInterface* pControl, controlModuleSDKs)
        {
            // 获取预设参数对话框
            QDialog* pDialog = pControl->getPresetParametersDialog(m_pDeviceManagementWidget);
            if (!pDialog)
            {
                continue;
            }

            // 获取配置名称
            QString configName = pDialog->property("ConfigName").toString();
            
            // 连接对话框完成信号
            connect(pDialog, &QDialog::finished, [this,configName](int result)
            {
                if (result != QDialog::Accepted)
                {
                    return;
                }
                
                // 获取预设参数
                QVariantMap params;
                if (!m_SDKManager->getPresetParameters(configName, params))
                {
                    return;
                }
                
                // 设置配置
                onSetConfig(configName, params);
            });
            

            QVariant ret;
            QVariantList args;

            // 调用开发者模式插件获取配置参数
            args << configName;
            bool ok = requestPluginFunctionCall(DEVELOPER_MODE_PLUGIN_NAME, "getConfigParams", args, ret);
            if (ok&&ret.isValid())
            {
                // 设置预设参数
                m_SDKManager->setPresetParameters(configName, ret.toMap());
            }

            // 注册预设参数菜单项
            ret.clear();
            args.clear();
            args << pDialog->property("MenuTitle") << QVariant::fromValue(pDialog);
            ok = requestPluginFunctionCall(DEVELOPER_MODE_PLUGIN_NAME, "registerPresetParamMenuItem", args, ret);
            if (!ok || !ret.toBool())
            {
                continue;
            }
        }
    }
    // 处理图像显示注销消息
    else if (message.startsWith(QString(CMD_UNREGISTER_IMAGE_DISPLAY ":")))
    {
        if (!m_SDKManager)
        {
            return;
        }
        
        // 解析消息，获取图像GUID
        QStringList parts = message.split(":");
        if (parts.size() >= 2) {
            const QString imageGuid = parts[1];
            
            // 如果被注销的图像GUID与当前打开的相机ID一致，则关闭相机
            if (!m_ConnectedId.isEmpty() && m_ConnectedId == imageGuid)
            {
                m_SDKManager->disconnectDevice(m_ConnectedId);
            }
        }
    }
    // 处理图像采集完成消息
    else if (message.startsWith(QString(CMD_IMAGE_COMPLETE ":")))
    {
        // 通知设备管理界面图像采集完成
        m_pDeviceManagementWidget->getImageComplete();
    }
}

/**
 * @brief 处理相机连接事件
 * @param deviceId 设备ID
 * @details 将相机连接事件转发给图像管理模块
 */
void DeviceManagementPlugin::onCameraConnected(const QString& deviceId)
{
    // 更新当前连接设备ID
    m_ConnectedId = deviceId;
    QString configName;
    QVariantMap params;
    if(!m_SDKManager->getDeviceParameters(deviceId,configName,params))
    {
        QVariant ret;
        QVariantList args;

        // 调用开发者模式插件获取配置参数
        args << configName;
        bool ok = requestPluginFunctionCall(DEVELOPER_MODE_PLUGIN_NAME, "getConfigParams", args, ret);
        if (ok && ret.toBool())
        {
           m_SDKManager->setDeviceParameters(deviceId,ret.toMap());
        }
    }

    // 将相机连接事件转发给图像管理模块，由其负责注册显示并通知SDK注册回调
    emit pluginMessageSent(DEVICE_MANAGEMENT_PLUGIN_NAME, QString(CMD_CAMERA_CONNECTED ":%1").arg(deviceId), IMAGE_MANAGEMENT_PLUGIN_NAME);
}

/**
 * @brief 处理相机断开事件
 * @param deviceId 设备ID
 * @details 将相机断开事件转发给图像管理模块
 */
void DeviceManagementPlugin::onCameraDisconnected(const QString& deviceId)
{
    // 清除当前连接设备ID
    if (m_ConnectedId == deviceId) {
        m_ConnectedId.clear();
    }
    
    // 仅转发给图像管理模块，由其负责注销显示并通知SDK取消回调
    emit pluginMessageSent(DEVICE_MANAGEMENT_PLUGIN_NAME, QString(CMD_CAMERA_DISCONNECTED ":%1").arg(deviceId), IMAGE_MANAGEMENT_PLUGIN_NAME);
}

/**
 * @brief 处理日志信号
 * @param logInfo 日志信息
 * @param logLevel 日志级别（0:INFO, 1:WARNING, 2:ERROR）
 * @param isSave 是否保存到文件
 */
void DeviceManagementPlugin::onWriteLog(const QString &logInfo, int logLevel, bool isSave)
{
    // 日志级别字符串映射
    static QStringList logLevelStr = {"INFO", "WARNING", "ERROR"};
    
    // 发送日志消息给日志插件
    emit pluginMessageSent(DEVICE_MANAGEMENT_PLUGIN_NAME, 
                          QString(CMD_LOG ":%1:%2:%3").arg(logLevelStr[logLevel]).arg(isSave?"true":"false").arg(logInfo), 
                          LOG_PLUGIN_NAME);
}

/**
 * @brief 设置配置
 * @param configName 配置名称
 * @param params 配置参数
 */
void DeviceManagementPlugin::onSetConfig(const QString &configName, const QVariantMap &params)
{
    QVariant ret;
    QVariantList args;
    
    // 调用开发者模式插件设置配置参数
    args << configName << QVariant::fromValue(params);
    requestPluginFunctionCall(DEVELOPER_MODE_PLUGIN_NAME, "setConfigParams", args, ret);
}
